﻿#include<iostream>
using namespace std;

//int main() {
//	cout << "Hello world!" << endl;
//	return 0;
//}

//namespace zc {
//	//可以定义变量
//	int number = 10;
//	//也可以定义函数
//	int Add(int x, int y) {
//		return x + y;
//	}
//	//还可以定义类型
//	struct N {
//		int a = 1;
//	}N;
//}
//
////2、using将某个成员展开
//using zc::Add;
//
////3、展开全部成员
//using namespace zc;	
//
//int main()
//{
//	//未声明的标识符
//	//cout << number << endl;
//
//	//1、指定命名空间访问
//	cout << zc::number << endl;
//
//	//2、using将某个成员展开
//	cout << Add(10, 20) << endl;
//
//	//3、展开全部
//	cout << number << endl;
//	cout << Add(1, 1) << endl;
//	cout << N.a<< endl;
//
//	return 0;
//}


////缺省参数
////1、全缺省参数
//void function_1(int a = 1, int b = 2, int c = 3) {
//	cout << "a=" << a << endl;
//	cout << "a=" << b << endl;
//	cout << "a=" << c << endl;
//}
//
////2、半缺省参数
//void function_2(int a, int b = 2, int c = 3) {
//	cout << "a=" << a << endl;
//	cout << "a=" << b << endl;
//	cout << "a=" << c << endl;
//}
//
//int main()
//{
//	function_1();
//	cout << endl;
//	function_1(10);
//	cout << endl;
//	function_2(20);
//	return 0;
//}

////函数重载
////下面两个是函数参数类型不同，构成函数重载
//int Add(int a = 1, int b = 1) {
//	return a + b;
//}
//
//double Add(double a, double b) {
//	return a + b;
//}
//
////参数类型顺序不同，也构成
//void func(int a, char b) {
//	cout << "a=" << a << ":" << "b=" << b << endl;
//}
//void func(char a, int b) {
//	cout << "a=" << a << ":" << "b=" << b << endl;
//}
//
//int main()
//{
//	cout << Add(10, 10) << endl;
//	cout << Add(1.2, 1.3) << endl;
//
//	func(10, 'A');
//	func('B', 20);
//
//	return 0;
//}


//int main()
//{
//	int num = 10;
//	//int& a;//没有初始化
//
//	int& b = num;
//	int c = 20;
//	b = c;//简单的赋值，因为C++规定引用不能改变指向
//	cout << &num << endl;
//	cout << &b << endl;
//	cout << &c << endl<<endl;
//
//	cout << num << endl;
//	cout << b << endl;
//	cout << c << endl;
//
//	return 0;
//}


//void Swap(int& x, int& y) {
//	int tmp = x;
//	x = y;
//	y = tmp;
//}
//
//void Swap1(int* a, int* b) {
//	int tmp = *a;
//	*a = *b;
//	*b = tmp;
//}
//
//int main()
//{
//	//引用
//	int number1 = 10, number2 = 20;
//	cout << number1 << " " << number2 << endl;
//	Swap(number1, number2);
//	cout << number1 << " " << number2 << endl;
//	cout << endl;
//
//	int number3 = 30, number4 = 40;
//	cout << number3 << " " << number4 << endl;
//	Swap1(&number3, &number4);
//	cout << number3 << " " << number4 << endl;
//	return 0;
//}


//int main()
//{
//	int a = 10;//可读可写的权限
//	const int& b = a;//const修饰后变为只读，此为权限缩小，是可以的。
//
//	const int c = 20;//只读权限
//	//int& d = c;//可读可写，权限放大，不可以的。必须加const修饰。
//	const int& d = c;
//
//	return 0;
//}
//


//int main()
//{
//	//int& a = 30;//一个常数，要想引用，必须加const
//	const int& a = 30;
//
//	//int& b = a + 2;//表达式有常性，也要用const修饰
//	const int& b = a + 2;
//
//	//隐式类型转换
//	double c = 66.66;
//	//int& d = c;//也是有常性的
//	const int& d = c;
//
//	return 0;
//}
//


// 实现⼀个ADD宏函数的常⻅问题
//#define ADD(int a, int b) return a + b;
//#define ADD(a, b) a + b;
//#define ADD(a, b) (a + b)

//// 正确的宏实现
//#define ADD(a, b) ((a) + (b))
//// 为什么不能加分号?
//// 要是加了分号，那么在直接输出后面调用函数就会出现错误。
//
//// 为什么要加外⾯的括号?
//// 解决运算符优先级问题的。
//
//// 为什么要加⾥⾯的括号?
////也是解决优先级问题的。
//int main()
//{
//	int ret = ADD(1, 2);
//	cout << ADD(1, 2) << endl;//要是加分号，此时就会出现错误。
//	cout << ADD(1, 2) * 5 << endl;//不叫外面的括号，那么此时会出现(1)+(2)*5=11
//	int x = 1, y = 2;
//	ADD(x & y, x | y); // -> (x&y+x|y)，不加里面括号也会出问题。
//	return 0;
//}



////2、类和对象
////定义格式
//class 类名
//{
//	//成员变量/属性
//	int a;
//	//成员函数/方法
//	int add(int x, int y) {
//		return x + y;
//	}
//};
//
//struct 类名
//{
//	//成员变量/属性
//	int a;
//	//成员函数/方法
//	int add(int x, int y) {
//		return x + y;
//	}
//};
//


//class Stack {
//public:
//	void Init(int n = 4);//在类中只做声明
//private:
//	int* array;
//	size_t capacity;
//	size_t top;
//};
////类外实现，此时就需要加作用域操作符，
////来确定Init是类方法。若不加Stack::，则会认为是全局函数。
//void Stack::Init(int n = 4) {
//	//开辟空间
//	array = (int*)malloc(sizeof(int)*n);
//	if (array == nullptr) {
//		perror("mallc failed!");
//		return;
//	}
//	//开辟成功
//	capacity = n;
//	top = 0;
//}
//
//int main()
//{
//	//实例化对象
//	Stack st;
//	st.Init();//不传实参，就是用缺省参数。
//
//	return 0;
//}


//#include<iostream>
//using namespace std;
//// 计算⼀下A/B/C实例化的对象是多⼤？
//class A
//{
//public:
//	void Print()
//	{
//		cout << _ch << endl;
//	}
//private:
//	char _ch;//1Byte
//	int _i;//4Byte
//};
//class B
//{
//public:
//	void Print()
//	{
//		//...
//	}
//};
//class C
//{};
//int main()
//{
//	A a;
//	B b;
//	C c;
//	cout << sizeof(a) << endl;//8
//	cout << sizeof(b) << endl;//1
//	cout << sizeof(c) << endl;//1
//	return 0;
//}



//
//#include<iostream>
//using namespace std;
//
////日期类
//class Date {
//public:
//	//void Init(Date* const this ,int year,int month,int day)
//	void Init(int year, int month, int day) {
//		_year = year;
//		_month = month;
//		_day = day;
//		////实际上是如下:
//		//this->_year = year;
//		//this->_month = month;
//		//this->_day = day;
//	}
//	//void print(Date* const this)
//	void print() {
//		cout << _year << ":" << _month << ":" << _day << endl;
//
//		////实际上：
//		//cout << this->_year << ":" << this->_month << ":" << this->_day << endl;
//	}
//
//private:
//	//只是声明
//	int	_year;
//	int	_month;
//	int _day;
//};
//
//int main()
//{
//	Date date1;
//	//date1.Init(&date1,2024, 6, 6);
//	date1.Init(2024, 6, 6);
//	//date1.print(&date1);
//	date1.print();
//
//	Date date2;
//	//date2.Init(&date1, 2024, 10, 1);
//	date2.Init(2024,10,1);
//	//date2.print(&date2);
//	date2.print();
//	return 0;
//}
//
//
//#include<iostream>
//#include<vector>
//using namespace std;
//
//int main()
//{
//	vector<int> nums({ 3,2,1 });
//
//	/*for (auto& e : nums) {
//		cout << e << " ";
//	}
//	cout << endl;
//	cout << *max_element(nums.begin(), nums.end()) << endl;*/
//	if (nums.size() <= 3) {
//		cout << *max_element(nums.begin(), nums.end()) << endl;
//	}
//	return 0;
//}

//#include <iostream>
//#include <vector>
//#include <algorithm> // for std::sort and std::unique
//
//int main() {
//    std::vector<int> vec = { 1,2, 2, 3, 4, 4, 5, 5, 5 };
//
//    // 1. 排序
//    std::sort(vec.begin(), vec.end());
//
//    // 2. 去重
//    auto last = std::unique(vec.begin(), vec.end());
//
//    // 3. 删除重复的元素
//    vec.erase(last, vec.end());
//
//    // 输出去重后的vector
//    for (const auto& elem : vec) {
//        std::cout << elem << " ";
//    }
//    cout << vec[vec.size() - 3] << endl;
//    return 0;
//}


//
////C语言栈结构
//#include<stdio.h>
//#include<assert.h>
//typedef int STDataType;
////定义结构体
//typedef struct Stack {
//	STDataType* array;
//	size_t top;
//	size_t capacity;
//}ST;
//
//void STInit(ST* st) {
//	assert(st);
//	st->array = nullptr;
//	st->capacity = st->top = 0;
//}
//
//void STDestroy(ST* st) {
//	assert(st);
//	if (st->array) {
//		free(st->array);
//		st->array = nullptr;
//	}
//	st->capacity = st->top = 0;
//}
//
//void STPush(ST* st, STDataType x) {
//	assert(st);
//	//扩容机制
//	if (st->top == st->capacity) {
//		size_t new_capacity = st->capacity == 0 ? 4 : st->capacity * 2;
//		STDataType* tmp = (STDataType*)realloc(st->array, new_capacity*sizeof(STDataType));
//		if (tmp==nullptr) {
//			perror("realloc failed");
//			return;
//		}
//		st->array = tmp;
//		st->capacity = new_capacity;
//	}
//	//插入数据
//	st->array[st->top] = x;
//	st->top++;
//}
//
//bool STEmpty(ST* st) {
//	assert(st);
//	return st->top == 0;
//}
//
//void STPop(ST* st) {
//	assert(st && st->top);
//	st->top--;
//}
//
//STDataType STTop(ST* st) {
//	assert(st && st->top);
//	return st->array[st->top-1];
//}
//
//size_t STSize(ST* st) {
//	assert(st);
//	return st->top;
//}
//
//int main()
//{
//	ST st;
//	STInit(&st);
//	STPush(&st, 1);
//	STPush(&st, 2);
//	STPush(&st, 3);
//	STPush(&st, 4);
//	STPush(&st, 5);
//	STPush(&st, 6);
//	printf("栈的数据个数：%zd\n", STSize(&st));
//	while (!STEmpty(&st)) {
//		printf("%d\n", STTop(&st));
//		STPop(&st);
//	}
//	printf("栈的数据个数：%zd\n", STSize(&st));
//	STDestroy(&st);
//	return 0;
//}
//
//


////C++版本的栈
//#include<iostream>
//#include<cassert>
//using namespace std;
//typedef int STDataType;
////定义Stack类
//class Stack {
////定义成员函数
//public:
//	//初始化函数
//	void Init(int n = 4) {
//		_array = (STDataType*)malloc(sizeof(STDataType)*n);
//		if (_array == nullptr) {
//			perror("malloc failed");
//			return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//
//	//入栈函数
//	void Push(STDataType x) {
//		//扩容
//		if (_capacity == _top) {
//			size_t new_acpacity = _capacity * 2;
//			STDataType* tmp = (STDataType*)realloc(_array, sizeof(STDataType) * new_acpacity);
//			if (tmp == nullptr) {
//				perror("realloc failed");
//				return;
//			}
//			_array = tmp;
//			_capacity = new_acpacity;
//		}
//		//插入数据
//		_array[_top++] = x;
//	}
//
//	size_t Size() {
//		return _top;
//	}
//	//出栈
//	void Pop()
//	{
//		assert(_top > 0); 
//		--_top;
//	}
//
//	bool Empty() {
//		return _top == 0;
//	}
//
//	STDataType Top() {
//		assert(_top > 0);
//		return _array[_top - 1];
//	}
//
//	void Destroy() {
//		if (_array) {
//			free(_array);
//			_array = nullptr;
//		}
//		_capacity = _top = 0;
//	}
//
////定义成员变量
//private:
//	STDataType* _array;
//	size_t _capacity;
//	size_t _top;
//};
//
//int main()
//{
//	Stack st;
//	st.Init();
//	st.Push(1);
//	st.Push(2);
//	st.Push(3);
//	st.Push(4);
//	st.Push(5);
//	st.Push(6);
//	st.Push(7);
//	cout << "栈的数据个数：" << st.Size() << endl;
//	while (!st.Empty()) {
//		cout << st.Top() << " ";
//		st.Pop();
//	}
//	cout << endl;
//	cout << "栈的数据个数：" << st.Size() << endl;
//	st.Destroy();
//	return 0;
//}





////构造函数
//#include<iostream>
//using namespace std;
//
////日期类
//class Date {
//public:
	////无参构造函数
	//Date() {
	//	_year = 2000;
	//	_month = 1;
	//	_day = 1;
	//}

	////带参构造函数
	//Date(int year, int month, int day) {
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}

	////全缺省构造函数
	//Date(int year = 2001, int month = 1, int day = 1) {
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}

//	void print() {
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;//调用默认构造函数,无参的不要加括号Date d1();是函数调用还是函数声明？？
//	//Date d2(2024,1, 1);//调用带参构造函数，带参构造函数和全缺省构造函数不能同时存在。全缺省和无参的也是不能同时存在。
//	d1.print();
//	//d2.print();
//
//
//	return 0;
//}


//
////析构函数
//#include<iostream>
//using namespace std;
////日期类
//class Date {
//public:
//	//全缺省构造函数
//	Date(int year = 2001, int month = 1, int day = 1) {
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print() {
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//	//==运算符重载
//	bool operator==(Date d2) {
//		return this->_year == d2._year 
//			&& this->_month == d2._month 
//			&& this->_day == d2._day;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//int main() {
//	Date d1(2024, 10, 1);
//	Date d2(2024, 10, 1);
//	cout << d1.operator==(d2) << endl;
//	cout << (d1 == d2) << endl;
//	cout << endl;
//	Date d3(2024, 10, 2);
//	Date d4(2024, 10, 1);
//	cout << d3.operator==(d4) << endl;
//	cout << (d3 == d4) << endl;
//	return 0;
//}


